// 使用统一导入模块，避免重复声明pathResolver
const helpersConfig = require('../../../config/helpers_config.js');
const {
	pageHelper,
	cloudHelper,
	requestHelper,
	timerHelper,
	cacheHelper,
	routerHelper,
	timeHelper,
	ProjectBiz,
	createStoreBindings
} = helpersConfig;

// 从path_import导入resourcesStore，并添加额外的安全检查
let { resourcesStore } = helpersConfig;

// 确保resourcesStore和CACHE_GROUP都存在且可访问
if (!resourcesStore) {
	console.error('[default_index.js] resourcesStore未定义，创建备用对象');
	resourcesStore = {
		CACHE_GROUP: {
			CACHE_KEY: 'DEFAULT_RESOURCES_CACHE_KEY',
			CACHE_TIME: 30 * 60 * 1000
		},
		error: null
	};
} else if (!resourcesStore?.CACHE_GROUP) {
	console.error('[default_index.js] resourcesStore?.CACHE_GROUP未定义，添加默认值');
	// 使用对象保护，确保resourcesStore存在
	resourcesStore = resourcesStore || {};
	resourcesStore.CACHE_GROUP = {
		CACHE_KEY: 'DEFAULT_RESOURCES_CACHE_KEY',
		CACHE_TIME: 30 * 60 * 1000
	};
}

// 创建一个本地常量CACHE_GROUP，避免直接引用可能为undefined的对象属性
const CACHE_GROUP = {
	CACHE_KEY: resourcesStore?.CACHE_GROUP?.CACHE_KEY || 'DEFAULT_RESOURCES_CACHE_KEY',
	CACHE_TIME: resourcesStore?.CACHE_GROUP?.CACHE_TIME || 30 * 60 * 1000
};

// 使用统一配置入口模式导入所需模块
const { PassportBiz } = require('../../../config/passport_biz_config.js');
const CACHE_KEY = 'WORKBENCH_DATA';
const CACHE_TIME = 30 * 60; // 缓存30分钟 (由原来的5分钟改为30分钟)
// 引入MobX相关依赖
const { indexStore } = require('../../../store/index_store');
const { userStore } = require('../../../config/user_store_config.js');
const { setting } = require('../../../config/projects_config.js');
const { logEvent } = require('../../../helpers/log_helper.js');
const { getNetworkStatus, listenNetworkStatus } = require('../../../helpers/network_helper.js');

// 内联 auth_middleware 功能，避免 require 错误
// const { authMiddleware } = require('../../my_user/helpers/index.js');

// 定义工作台相关的API路由
const API_ROUTES = {
	WORK_DATA: 'home/work_data',
	DYNAMIC_LIST: 'home/dynamic_list',
	STATISTICS: 'home/statistics',
	NOTIFICATIONS: 'home/notifications'
};

// 定义工作台缓存组和优先级
const WORKBENCH_CACHE = {
    GROUP: cacheHelper?.CACHE_GROUP?.USER || 'USER',  // 使用用户相关缓存组，有防御性检查
    PRIORITY: cacheHelper?.CACHE_PRIORITY?.HIGH || 'HIGH',  // 使用高优先级，有防御性检查
    SECTIONS: {
        WORK_DATA: 'WORK_DATA',
        DYNAMIC_LIST: 'DYNAMIC_LIST',
        STATISTICS: 'STATISTICS',
        NOTIFICATIONS: 'NOTIFICATIONS' 
    }
};

Page({
	/**
	 * 页面的初始数据
	 */
	data: {
		isLoad: false,
		isRefreshing: false,
		// 动画数据
		refreshAnimation: {},
		isAdmin: false,
		// 企业微信环境标识
		isInWxWork: false,
		
		// 模块切换相关
		moduleOptions: ['OA工作台', 'PLM工作台', 'CRM'],
		moduleIndex: 1,
		isModuleDropdownOpen: false, // 添加下拉菜单状态
		
		// UI显示数据
		userInfo: null,
		workData: {},
		dynamicList: [],
		
		// PLM工作台数据
		plmWorkData: {
			taskTotal: 0,    // 任务总数
			inProgress: 0,   // 进行中的任务
			approvalTotal: 0, // 审批总数
			developTotal: 0  // 研发项目总数
		},
		plmDynamicList: [],   // PLM动态列表
		
		// CRM数据
		crmData: {
			customerTotal: 0,  // 客户总数
			followupTotal: 0,  // 跟进次数
			opportunityTotal: 0, // 销售机会
			dealTotal: 0       // 成交数
		},
		crmDynamicList: [],    // CRM动态列表
		
		// 页面状态
		refreshing: false,
		
		// 当前页面的配置参数
		tabList: [
			{ label: '工作台', id: 'work' },
			{ label: '动态', id: 'dynamic' },
			{ label: '应用', id: 'apps' }
		],
		currentTab: 'work',
	},

	/**
	 * 生命周期函数--监听页面加载
	 */
	onLoad: async function (options) {
		// 网络检测
		const net = await getNetworkStatus();
		if (!net.isConnected) {
			wx.showToast({ title: '当前无网络，请检查连接', icon: 'none' });
		} else if (net.networkType === '2g') {
			wx.showToast({ title: '当前为2G弱网，体验可能受影响', icon: 'none' });
		}
		listenNetworkStatus((res) => {
			if (!res.isConnected) wx.showToast({ title: '网络已断开', icon: 'none' });
			else if (res.networkType === '2g') wx.showToast({ title: '当前为2G弱网', icon: 'none' });
		});
		logEvent('page_load', { page: 'default_index' });
		
		// 检测是否在企业微信环境中
		try {
			const systemInfo = wx.getSystemInfoSync();
			this.setData({
				isInWxWork: systemInfo.environment === 'wxwork'
			});
			console.log('是否在企业微信环境中:', this.data.isInWxWork);
		} catch (e) {
			console.error('获取系统信息失败', e);
			this.setData({
				isInWxWork: false
			});
		}
		
		// 内联 checkAuth，避免 require 错误
		const checkAuth = async (pageCtx, loginUrl) => {
			// 兼容异步初始化
			if (userStore.init) await userStore.init();
			if (!userStore.isLogin) {
				// 如果在企业微信环境中，不要立即重定向到登录页
				if (this.data.isInWxWork) {
					console.log('在企业微信环境中，等待自动登录');
					return false;
				}
				wx.redirectTo({ url: loginUrl });
				return false;
			}
			return true;
		};
		
		// 直接调用内联 checkAuth，不再 require authMiddleware
		await checkAuth(this, '/projects/oa/pages/my_user/login/my_login');
		
		// 创建动画实例
		this.refreshAnimation = wx.createAnimation({
			duration: 500,
			timingFunction: 'ease'
		});
		
		// 创建MobX Store绑定 - 工作台数据
		this.indexStoreBindings = createStoreBindings(this, {
			store: indexStore,
			fields: [
				'workData', 
				'statItems', 
				'statCards', 
				'quickLinks', 
				'dynamicList', 
				'statistics', 
				'notifications',
				'pageStatus',
				'unreadNotificationCount',
				'dailyQuote'
			],
			actions: [
				'loadAllData',
				'backgroundRefresh',
				'markNotificationAsRead',
				'updateWorkData', 
				'updateDynamicList', 
				'updateStatistics', 
				'updateNotifications', 
				'setPageLoading',
				'setPageRefreshing',
				'updateQuickLinks',
				'clearPageError',
				'clearCache'
			]
		});
		
		// 创建MobX Store绑定 - 用户数据
		this.userStoreBindings = createStoreBindings(this, {
			store: userStore,
			fields: ['isLogin', 'user', 'isAdmin'],
			actions: ['init', 'loginSilence', 'getUserInfo']
		});
		
		// 初始化登录状态
		await this._checkLoginState();
		
		// 设置加载完成
		this.setData({
			isLoad: true
		});
		
		// 启动自动刷新
		this._startAutoRefresh();
	},

	/**
	 * 检查登录状态并加载数据
	 */
	_checkLoginState: async function() {
		try {
			// 初始化用户状态
			const initResult = await this.init();
			if (!userStore.isLogin) {
				// 检查是否在企业微信环境中
				if (this.data.isInWxWork) {
					console.log('企业微信环境中，尝试企业微信登录');
					// 尝试企业微信静默登录，最多尝试3次
					let retryCount = 0;
					const maxRetries = 3;
					
					const tryWecomLogin = async () => {
						// 尝试企业微信登录
						try {
							if (userStore.loginByWecom) {
								const wecomResult = await userStore.loginByWecom();
								if (wecomResult) {
									console.log('企业微信登录成功');
									this.setData({ isLogin: true });
									return true;
								}
							}
							
							console.log(`企业微信登录失败，尝试次数: ${retryCount + 1}/${maxRetries}`);
							return false;
						} catch (e) {
							console.error('企业微信登录出错', e);
							return false;
						}
					};
					
					// 第一次尝试
					let loginSuccess = await tryWecomLogin();
					
					// 如果失败，尝试重试
					while (!loginSuccess && retryCount < maxRetries - 1) {
						retryCount++;
						await new Promise(resolve => setTimeout(resolve, 1000)); // 等待1秒再尝试
						loginSuccess = await tryWecomLogin();
					}
					
					if (loginSuccess) {
						// 有登录状态，加载首页数据
						await this._loadAllData();
						// 获取完整用户信息
						await this.getUserInfo();
						return true;
					}
				}
				
				// 尝试常规静默登录
				const loginResult = await this.loginSilence();
				if (!loginResult) {
					console.log('静默登录失败，显示未登录状态');
					this.setData({ isLogin: false });
					return false;
				}
			}
			// 强制同步data
			this.setData({ isLogin: userStore.isLogin });
			// 有登录状态，加载首页数据
			await this._loadAllData();
			// 获取完整用户信息
			await this.getUserInfo();
			return true;
		} catch (err) {
			console.error('登录检查出错', err);
			this.setData({ isLogin: false });
			return false;
		}
	},

	/**
	 * 加载所有首页数据
	 */
	_loadAllData: async function() {
		if (!userStore.isLogin) return;
		try {
			await this.loadAllData();
		} catch (err) {
			console.error('加载首页数据出错', err);
		}
	},

	/**
	 * 生命周期函数--监听页面初次渲染完成
	 */
	onReady: function () { },

	/**
	 * 生命周期函数--监听页面显示
	 */
	onShow: async function () {
		// 企业微信环境下，可能需要额外检查登录状态
		if (this.data.isInWxWork && !this.data.isLogin) {
			console.log('企业微信环境，页面显示时重新检查登录状态');
			const loginStatus = await this._checkLoginState();
			if (loginStatus) {
				console.log('企业微信环境下自动登录成功，刷新页面数据');
				// 确保数据加载
				this._loadAllData();
			}
		}
		
		// 非活跃超过5分钟，自动刷新数据
		const lastActiveTime = this.lastActiveTime || 0;
		const now = Date.now();
		if (now - lastActiveTime > 5 * 60 * 1000) {
			console.log('页面重新激活，刷新数据');
			this._doBackgroundRefresh();
		}
		this.lastActiveTime = now;
		
		// 如果在页面打开过程中，用户已登录信息变更，需要刷新页面信息
		if (this.data.isLoad && userStore.isLogin !== this.data.isLogin) {
			console.log('登录状态变化，刷新页面信息');
			this.setData({ isLogin: userStore.isLogin });
			if (userStore.isLogin) {
				await this._loadAllData();
			}
		}
	},

	/**
	 * 生命周期函数--监听页面隐藏
	 */
	onHide: function() {
		// 清除自动刷新定时器
		if (this.refreshTimer) {
			clearInterval(this.refreshTimer);
		}
	},

	/**
	 * 生命周期函数--监听页面卸载
	 */
	onUnload: function() {
		// 清除自动刷新定时器
		if (this.refreshTimer) {
			clearInterval(this.refreshTimer);
		}
		
		// 清理MobX绑定
		this.indexStoreBindings.destroyStoreBindings();
		this.userStoreBindings.destroyStoreBindings();
	},

	/**
	 * 切换到PLM项目
	 */
	switchToPLM: function() {
		this.setData({
			moduleIndex: 1
		});
		this.loadPLMData();
	},

	/**
	 * 处理模块切换
	 */
	onModuleChange: function(e) {
		const index = parseInt(e.detail.value);
		console.log('[模块切换] 模块切换为:', index);
		
		this.setData({
			moduleIndex: index
		});
		
		// 如果切换到PLM工作台，加载PLM数据
		if (index === 1) {
			console.log('[PLM] 加载PLM数据');
			this.loadPLMData();
		} 
		// 如果切换到CRM，加载CRM数据
		else if (index === 2) {
			console.log('[CRM] 加载CRM数据');
			this.loadCRMData();
		} 
		else {
			console.log('[OA] 加载OA数据');
		}
	},

	/**
	 * 加载PLM相关数据
	 */
	loadPLMData: function() {
		// 避免重复加载数据
		if (this.data.plmLoaded) {
			console.log('[PLM] 数据已加载，跳过');
			return;
		}
		
		console.log('[PLM] 开始加载PLM数据');
		wx.showLoading({
			title: '加载中...',
		});
		
		// 这里应该调用云函数获取PLM数据
		// 由于是模拟，这里直接使用模拟数据
		setTimeout(() => {
			console.log('[PLM] 使用模拟数据');
			this.setData({
				plmWorkData: {
					taskTotal: 5,
					inProgress: 2,
					approvalTotal: 3,
					developTotal: 4
				},
				plmDynamicList: [],
				plmLoaded: true
			});
			
			wx.hideLoading();
			console.log('[PLM] 数据加载完成');
		}, 300);
	},

	/**
	 * PLM相关导航方法
	 */
	gotoPLM: function() {
		console.log('[PLM] 导航到PLM主页');
		wx.navigateTo({
			url: '/projects/plm/pages/index/index',
		});
	},

	gotoCompletedApproval: function() {
		console.log('[PLM] 导航到完成审批');
		wx.navigateTo({
			url: '/projects/plm/pages/approval/completed/completed',
		});
	},

	gotoPendingApproval: function() {
		console.log('[PLM] 导航到待完审批');
		wx.navigateTo({
			url: '/projects/plm/pages/approval/pending/pending',
		});
	},

	gotoApproved: function() {
		console.log('[PLM] 导航到已审批');
		wx.navigateTo({
			url: '/projects/plm/pages/approval/approved/approved',
		});
	},

	gotoInitiateApproval: function() {
		console.log('[PLM] 导航到发起审批');
		wx.navigateTo({
			url: '/projects/plm/pages/approval/initiate/initiate',
		});
	},

	gotoCreateProject: function() {
		console.log('[PLM] 导航到新建项目');
		wx.navigateTo({
			url: '/projects/plm/pages/project/edit/project_edit',
		});
	},

	gotoProjectList: function() {
		console.log('[PLM] 导航到项目列表');
		wx.navigateTo({
			url: '/projects/plm/pages/project/list/project_list',
		});
	},

	gotoProjectManage: function() {
		console.log('[PLM] 导航到项目管理');
		wx.navigateTo({
			url: '/projects/plm/pages/project/manage/project_manage',
		});
	},

	gotoResourceList: function() {
		console.log('[PLM] 导航到资源管理');
		wx.navigateTo({
			url: '/projects/plm/pages/resource/list/resource_list',
		});
	},

	gotoSupplyManage: function() {
		console.log('[PLM] 导航到供应链管理');
		wx.navigateTo({
			url: '/projects/plm/pages/supply/manage/supply_manage',
		});
	},

	gotoProcessManage: function() {
		console.log('[PLM] 导航到工艺管理');
		wx.navigateTo({
			url: '/projects/plm/pages/process/manage/process_manage',
		});
	},

	gotoQualityManage: function() {
		console.log('[PLM] 导航到质量管理');
		wx.navigateTo({
			url: '/projects/plm/pages/quality/manage/quality_manage',
		});
	},

	gotoDataAnalytics: function() {
		console.log('[PLM] 导航到数据分析');
		wx.navigateTo({
			url: '/projects/plm/pages/analytics/dashboard/analytics_dashboard',
		});
	},

	viewAllDynamics: function() {
		console.log('[PLM] 查看全部动态');
		wx.navigateTo({
			url: '/projects/plm/pages/dynamic/list/dynamic_list',
		});
	},

	url: function (e) {
		console.log('[DEFAULT_INDEX] url函数参数:', e);
		
		const url = e.currentTarget.dataset.url;
		
		if (!url) {
			console.error('[DEFAULT_INDEX] 跳转地址为空');
			return;
		}
		
		console.log('[DEFAULT_INDEX] 原始跳转地址:', url);
		
		// 处理参数
		let params = {};
		if (e.currentTarget.dataset.params) {
			try {
				if (typeof e.currentTarget.dataset.params === 'string') {
					params = JSON.parse(e.currentTarget.dataset.params);
				} else {
					params = e.currentTarget.dataset.params;
				}
			} catch (err) {
				console.error('[DEFAULT_INDEX] 参数解析失败:', err);
			}
		}
		
		// 从path_import中已经导入了routerHelper
		// 不需要再次引用
		
		// 记录传递的参数
		console.log('[DEFAULT_INDEX] 路由参数:', params);
		
		// 根据是否为相对路径决定处理方式
		if (url.startsWith('../')) {
			// 解析当前页面路径
			const pages = getCurrentPages();
			const currentPage = pages[pages.length - 1];
			const currentPath = currentPage.route;
			
			console.log('[DEFAULT_INDEX] 当前页面路径:', currentPath);
			
			// 将当前路径拆分为数组
			const pathParts = currentPath.split('/');
			// 移除最后一部分（页面名）
			pathParts.pop();
			
			// 处理相对路径
			const relativePath = url;
			const relativePathParts = relativePath.split('/');
			
			let resultPath = [...pathParts];
			
			// 处理每一部分
			for (let i = 0; i < relativePathParts.length; i++) {
				const part = relativePathParts[i];
				if (part === '..') {
					// 向上一级目录
					resultPath.pop();
				} else if (part && part !== '.') {
					// 添加子目录或文件名
					resultPath.push(part);
				}
			}
			
			// 组合回完整路径
			const absolutePath = resultPath.join('/');
			console.log('[DEFAULT_INDEX] 相对路径转换后:', absolutePath);
			
			// 使用路由助手导航
			routerHelper.navigateTo(absolutePath, params);
		} else {
			// 直接路径处理
			// 去掉开头的斜杠
			let normalizedUrl = url;
			if (normalizedUrl.startsWith('/')) {
				normalizedUrl = normalizedUrl.substring(1);
			}
			
			console.log('[DEFAULT_INDEX] 使用路径:', normalizedUrl);
			routerHelper.navigateTo(normalizedUrl, params);
		}
	},

	/**
	 * 用户点击右上角分享
	 */
	onShareAppMessage: function () {
		return {
			title: setting.SETUP_SHARE_TITLE,
			path: 'projects/oa/pages/default/index/default_index'
		}
	},

	/**
	 * 启动自动刷新
	 */
	_startAutoRefresh: function() {
		// 清除可能存在的旧定时器
		if (this.refreshTimer) {
			clearInterval(this.refreshTimer);
		}
		
		// 只有在已登录状态下才开启自动刷新
		if (this.data.isLogin) {
			// 每5分钟刷新一次数据
			this.refreshTimer = setInterval(() => {
				if (this.data.isLogin) {
					console.log('执行自动刷新');
					this._doBackgroundRefresh();
				} else {
					// 如果用户已登出，停止刷新
					clearInterval(this.refreshTimer);
				}
			}, 5 * 60 * 1000);
		}
	},

	/**
	 * 缓存相关方法 - 使用新的缓存机制
	 */
	_saveSectionCache: function(section, data) {
		if (!section || !data) return;
		
		try {
			const key = `${CACHE_KEY}_${section}`;
			cacheHelper.set(
				key, 
				data, 
				CACHE_TIME, 
				WORKBENCH_CACHE.GROUP, 
				WORKBENCH_CACHE.PRIORITY
			);
		} catch (err) {
			console.error(`保存缓存[${section}]失败:`, err);
		}
	},

	_checkCacheNeedsRefresh: function() {
		try {
			// 检查各部分缓存是否存在且有效
			const sections = Object.values(WORKBENCH_CACHE.SECTIONS);
			for (const section of sections) {
				if (!cacheHelper.has(`${CACHE_KEY}_${section}`)) {
					console.log(`缓存检查：${section} 缓存不存在`);
					return true;
				}
			}
			
			// 如果所有缓存都存在且有效，则不需要刷新
			return false;
		} catch (err) {
			console.error('检查缓存是否需要刷新失败：', err);
			return true; // 出错时默认需要刷新
		}
	},

	_clearAllCache: function() {
		try {
			// 清除所有工作台缓存
			const sections = Object.values(WORKBENCH_CACHE.SECTIONS);
			for (const section of sections) {
				cacheHelper.remove(`${CACHE_KEY}_${section}`);
			}
			console.log('已清除所有工作台缓存');
		} catch (err) {
			console.error('清除工作台缓存失败：', err);
		}
	},

	/**
	 * 获取缓存统计信息
	 */
	getCacheStats: function() {
		const stats = cacheHelper.getStats();
		console.log('缓存统计信息：', stats);
		
		let message = '缓存统计：\n';
		message += `总大小：${stats.total.size.toFixed(2)}KB/${stats.total.limit}KB\n`;
		message += `总项目数：${stats.total.count}\n\n`;
		
		message += '分组统计：\n';
		for (const group in stats.groups) {
			const groupStat = stats.groups[group];
			message += `${group}：${groupStat.size.toFixed(2)}KB/${groupStat.limit}KB (${groupStat.count}项)\n`;
		}
		
		pageHelper.showModal('缓存统计', message);
	},

	/**
	 * 动画相关方法
	 */
	_playRefreshAnimation: function() {
		this.refreshAnimation.rotate(720).step();
		this.setData({
			refreshAnimation: this.refreshAnimation.export()
		});
	},

	/**
	 * 处理消息点击
	 */
	onMessageTap: function(e) {
		const id = e.currentTarget.dataset.id;
		const url = e.currentTarget.dataset.url;
		
		try {
			// 使用MobX Store的方法标记通知为已读
			this.markNotificationAsRead(id);
			
			// 从本地存储获取通知数据，更新状态
			const notifications = wx.getStorageSync('local_notifications') || [];
			
			// 更新消息状态为已读
			const updatedNotifications = notifications.map(item => {
				if (item.id === id) {
					return { ...item, status: 'read' };
				}
				return item;
			});
			
			// 保存更新后的通知数据
			wx.setStorageSync('local_notifications', updatedNotifications);
			
			// 如果有URL，则导航到对应页面
			if (url) {
				this.url({
					currentTarget: {
						dataset: { url }
					}
				});
			}
		} catch (err) {
			console.error('处理消息点击失败', err);
		}
	},

	/**
	 * 处理动态点击
	 */
	onDynamicTap: function(e) {
		const item = e.currentTarget.dataset.item;
		if (!item) return;
		
		if (item.type === 'notification') {
			// 标记为已读
			this.onMessageTap({
				currentTarget: {
					dataset: {
						id: item._id,
						url: item.path
					}
				}
			});
		} else if (item.path) {
			this.url({
				currentTarget: {
					dataset: { 
						url: item.path 
					}
				}
			});
		} else if (item.docId) {
			// 处理文档类型动态
			this.url({
				currentTarget: {
					dataset: { 
						url: `../../knowledge/detail/knowledge_detail?id=${item.docId}` 
					}
				}
			});
		}
	},

	/**
	 * 打开AI助手页面
	 */
	onAiTap: function() {
		wx.showToast({
			title: 'AI助手功能开发中',
			icon: 'none'
		});
	},

	/**
	 * 扫码功能
	 */
	scanQrCode: function() {
		wx.scanCode({
			success: (res) => {
				console.log('扫码结果：', res);
				wx.showToast({
					title: '扫码成功',
					icon: 'success'
				});
			},
			fail: (err) => {
				console.error('扫码失败：', err);
				wx.showToast({
					title: '扫码失败',
					icon: 'error'
				});
			}
		});
	},

	// 导航到产品页面
	navToProduct: function(e) {
		let id = e.currentTarget.dataset.id;
		let title = id === 1 ? '磁编霍尔' : '无刷电机控制器';
		
		// 创建一个简单页面显示"功能待开发"
		wx.navigateTo({
			url: '/pages/test1/test1?title=' + title,
		});
	},

	/**
	 * 跳转到公司详情页
	 */
	navToCompanyDetail: function() {
		wx.navigateTo({
			url: '/projects/oa/pages/about/company_detail/company_detail',
		})
	},

	/**
	 * 页面相关事件处理函数--监听用户下拉动作
	 */
	onPullDownRefresh: async function () {
		if (this.data.isRefreshing) return;

		this.setData({
			isRefreshing: true
		});
		
		// 使用本地方法设置状态
		if (this.setPageRefreshing) {
			this.setPageRefreshing(true);
		}

		// 播放刷新动画
		this._playRefreshAnimation();

		try {
			// 强制刷新所有数据
			await this._loadAllData();
		} catch (err) {
			console.error('刷新数据失败：', err);
		}

		setTimeout(() => {
			this.setData({
				isRefreshing: false
			});
			
			// 使用本地方法设置状态
			if (this.setPageRefreshing) {
				this.setPageRefreshing(false);
			}
			
			wx.stopPullDownRefresh();
		}, 500);
	},

	/**
	 * 智能更新，仅更新变化的数据，优化性能
	 */
	_smartUpdate: function(data) {
		// diff比较，只更新变化的字段
		const updates = {};
		for (const key in data) {
			if (JSON.stringify(this.data[key]) !== JSON.stringify(data[key])) {
				updates[key] = data[key];
			}
		}
		
		if (Object.keys(updates).length > 0) {
			this.setData(updates);
		}
	},

	/**
	 * 处理快捷入口点击 - 特殊处理有handler的项
	 */
	onQuickLinkTap: function(e) {
		const index = e.currentTarget.dataset.index;
		const item = this.data.quickLinks[index];
		logEvent('quick_link_tap', { index, item });
		
		if (item && item.handler) {
			// 如果有自定义处理函数
			if (item.handler === 'cleanDuplicateProjects') {
				// 直接调用本页面的清理方法
				this.cleanDuplicateProjects();
			} else if (typeof this[item.handler] === 'function') {
				this[item.handler]();
			} else if (typeof indexStore[item.handler] === 'function') {
				indexStore[item.handler]();
			} else {
				console.error('未找到处理函数:', item.handler);
			}
		} else if (item && item.url) {
			// 正常导航
			this.url({
				currentTarget: {
					dataset: { url: item.url }
				}
			});
		}
	},

	/**
	 * 清理重复的项目数据
	 */
	cleanDuplicateProjects: function() {
		// 不再检查管理员权限
		// const AdminBiz = require('../../../store/admin_biz_config.js');
		// let isAdmin = AdminBiz.getAdminToken() ? true : false;
		// 
		// if (!isAdmin) {
		//	pageHelper.showModal('温馨提示', '该功能仅管理员可操作，请先登录管理员账号');
		//	return;
		// }
		
		pageHelper.showConfirm('确认操作', '警告：此操作将清理系统中所有项目数据，且无法恢复！请确认您需要执行此操作。', () => {
			// 直接调用ProjectBiz中的清理方法
			try {
				// 显示加载中提示
				wx.showLoading({
					title: '清理中...',
					mask: true
				});
				
				// 然后调用云函数清理服务器数据
				ProjectBiz.clearAllProjects().then(res => {
					console.log('[清零数据] 清理结果:', res);
					
					// 隐藏加载提示
					wx.hideLoading();
					
					// 显示成功提示
					pageHelper.showSuccToast('数据清理成功');
					
					// 强制重新加载页面
					this._loadAllData();
					
					// 延迟后自动跳转到首页再返回，强制刷新
					setTimeout(() => {
						const currentPages = getCurrentPages();
						
						// 如果只有一个页面，表示当前就在首页，直接刷新即可
						if (currentPages.length <= 1) {
							this.onShow(); // 重新触发页面显示逻辑
							return;
						}
						
						// 否则先跳转到首页再返回当前页面
						wx.switchTab({
							url: '/projects/oa/pages/default/index/default_index',
							success: () => {
								// 成功后无需操作，页面会自动刷新
								console.log('[清零数据] 已跳转到首页');
							}
						});
					}, 1500);
				}).catch(err => {
					wx.hideLoading();
					console.error('[清零数据] 项目清理失败:', err);
					pageHelper.showModal('操作失败', '数据清理失败: ' + (err.message || '未知错误，请稍后重试'));
				});
			} catch (error) {
				wx.hideLoading();
				console.error('[清零数据] 操作异常:', error);
				pageHelper.showModal('操作异常', '请稍后重试');
			}
		});
	},

	/**
	 * 后台刷新数据
	 */
	_doBackgroundRefresh: async function() {
		try {
			console.log('正在后台刷新数据...');
			
			// 使用本地数据加载方法
			return await this._loadAllData();
		} catch (err) {
			console.error('后台刷新数据失败：', err);
			return null;
		}
	},

	/**
	 * 切换Tab
	 */
	switchTab: function(e) {
		let tab = e.currentTarget.dataset.tab;
		logEvent('switch_tab', { tab });
		this.setData({
			currentTab: tab
		});
	},

	/**
	 * 点击快捷方式
	 */
	bindQuickTap: function(e) {
		let item = e.currentTarget.dataset.item;
		logEvent('quick_link_btn', { item });
		
		if (!item) return;
		
		// 如果有URL，跳转页面
		if (item.url) {
			wx.navigateTo({
				url: item.url,
			});
			return;
		}
		
		// 如果有处理函数，调用对应方法
		if (item.handler && typeof this[item.handler] === 'function') {
			this[item.handler]();
			return;
		}
	},

	/**
	 * 跳转登录页面
	 */
	bindLoginTap: function(e) {
		console.log('跳转到登录页面');
		wx.navigateTo({
			url: '/projects/oa/pages/my_user/login/my_login',
			success: () => {
				console.log('成功跳转到登录页面');
			},
			fail: (err) => {
				console.error('跳转登录页面失败', err);
				// 尝试使用另一种路径
				wx.navigateTo({
					url: '../../../../../pages/my_user/login/my_login'
				});
			}
		});
	},

	/**
	 * 点击统计项
	 */
	onStatItemTap: function(e) {
		try {
			const index = parseInt(e.currentTarget.dataset.index);
			
			if (isNaN(index) || index < 0 || index >= this.data.statItems.length) {
				console.error('统计项索引无效:', index);
				return;
			}
			
			console.log('点击统计项:', index, this.data.statItems[index]);
			const item = this.data.statItems[index];
			
			// 根据点击的统计项key决定跳转页面
			switch (item.key) {
				case 'approvalTotal':
					// 跳转到审批列表
					wx.navigateTo({
						url: '../../flow/my_list/flow_my_list'
					});
					break;
				case 'taskTotal':
					// 跳转到任务列表
					wx.navigateTo({
						url: '../../task/index/task_index'
					});
					break;
				case 'taskDoing':
					// 跳转到进行中的任务列表
					wx.navigateTo({
						url: '../../task/index/task_index?status=1'
					});
					break;
				case 'projectTotal':
					// 跳转到项目列表
					wx.navigateTo({
						url: '../../project/list/project_list'
					});
					break;
				default:
					console.log('未处理的统计项点击:', item.key);
			}
		} catch (err) {
			console.error('处理统计项点击出错:', err);
		}
	},

	// 角色模拟
	gotoRoleSimulation: function() {
		console.log('[PLM] 导航到角色模拟');
		wx.navigateTo({
			url: '/projects/plm/pages/project/tools/role_simulation',
		});
	},

	/**
	 * 加载CRM相关数据
	 */
	loadCRMData: function() {
		// 避免重复加载数据
		if (this.data.crmLoaded) {
			console.log('[CRM] 数据已加载，跳过');
			return;
		}
		
		console.log('[CRM] 开始加载CRM数据');
		wx.showLoading({
			title: '加载中...',
		});
		
		// 这里应该调用云函数获取CRM数据
		// 由于是模拟，这里直接使用模拟数据
		setTimeout(() => {
			console.log('[CRM] 使用模拟数据');
			this.setData({
				crmData: {
					customerTotal: 120,
					followupTotal: 56,
					opportunityTotal: 32,
					dealTotal: 18
				},
				crmDynamicList: [],
				crmLoaded: true
			});
			
			wx.hideLoading();
			console.log('[CRM] 数据加载完成');
		}, 300);
	},

	/**
	 * CRM相关导航方法
	 */
	gotoCRMCustomers: function() {
		console.log('[CRM] 导航到客户管理');
		wx.navigateTo({
			url: '/projects/crm/pages/customer/list/customer_list',
		});
	},

	gotoCRMContacts: function() {
		console.log('[CRM] 导航到联系人');
		wx.navigateTo({
			url: '/projects/crm/pages/contact/list/contact_list',
		});
	},

	gotoCRMOpportunities: function() {
		console.log('[CRM] 导航到销售机会');
		wx.navigateTo({
			url: '/projects/crm/pages/opportunity/list/opportunity_list',
		});
	},

	gotoCRMDeals: function() {
		console.log('[CRM] 导航到成交管理');
		wx.navigateTo({
			url: '/projects/crm/pages/deal/list/deal_list',
		});
	},

	gotoCRMProducts: function() {
		console.log('[CRM] 导航到产品管理');
		wx.navigateTo({
			url: '/projects/crm/pages/product/list/product_list',
		});
	},

	gotoCRMFollowups: function() {
		console.log('[CRM] 导航到跟进记录');
		wx.navigateTo({
			url: '/projects/crm/pages/followup/list/followup_list',
		});
	},

	gotoCRMStatistics: function() {
		console.log('[CRM] 导航到销售统计');
		wx.navigateTo({
			url: '/projects/crm/pages/statistics/dashboard/statistics_dashboard',
		});
	},

	gotoCRMSettings: function() {
		console.log('[CRM] 导航到CRM设置');
		wx.navigateTo({
			url: '/projects/crm/pages/settings/index/settings_index',
		});
	},

	viewAllCRMDynamics: function() {
		console.log('[CRM] 查看全部销售动态');
		wx.navigateTo({
			url: '/projects/crm/pages/dynamic/list/dynamic_list',
		});
	},

	/**
	 * 切换模块下拉菜单显示/隐藏
	 */
	toggleModuleDropdown: function() {
		this.setData({
			isModuleDropdownOpen: !this.data.isModuleDropdownOpen
		});
	},

	/**
	 * 选择模块
	 */
	selectModule: function(e) {
		const index = e.currentTarget.dataset.index;
		
		// 关闭下拉菜单
		this.setData({
			moduleIndex: index,
			isModuleDropdownOpen: false
		});
		
		// 加载对应模块数据
		if (index === 0) {
			// OA工作台
			this._loadAllData();
		} else if (index === 1) {
			// PLM工作台
			this.loadPLMData();
		} else if (index === 2) {
			// CRM
			this.loadCRMData();
		}
	},

	/**
	 * 点击页面其他地方时关闭下拉菜单
	 */
	onTapPage: function() {
		if (this.data.isModuleDropdownOpen) {
			this.setData({
				isModuleDropdownOpen: false
			});
		}
	},

	/**
	 * 初始化快捷入口
	 */
	_initQuickLinks: function() {
		// 原有的快捷入口数据
		const quickLinks = [
			// ... existing code ...
		];
		
		this.updateQuickLinks(quickLinks);
	},
})